import { defineStore } from 'pinia';
import { ref, computed } from 'vue';

import axios from '@/utils/axios';

export const useNotificationStore = defineStore('notification', () => {
    const notifications = ref<any[]>([]);
    const unreadCount = ref(0);
    const loading = ref(false);
    const loadingMore = ref(false); // 加载更多的状态（保留以兼容UI显示）
    const hasMore = ref(false); // 默认设置为false，因为一次性加载所有数据

    // 计算未读通知数量
    const hasUnread = computed(() => notifications.value.some(n => !n.isRead));

    // 最近5条未读通知
    const recentNotifications = computed(() =>
        notifications.value.slice(0, 5).filter(n => !n.isRead)
    );

    // 设置通知列表
    const setNotifications = (newNotifications: any[]) => {
        notifications.value = newNotifications;
        updateUnreadCount();
    };

    // 添加新通知
    const addNotification = (notification: any) => {
        notification.id = Date.now() + Math.random();
        notification.createdAt = new Date();
        notification.isRead = false;
        notifications.value.unshift(notification);
        updateUnreadCount();
    };

    // 标记单条通知为已读
    const markAsRead = async (notificationId: number) => {
        const notification = notifications.value.find(n => n.id === notificationId);
        if (notification && !notification.isRead) {
            notification.isRead = true;
            updateUnreadCount();
            
            try {
                console.log('同步标记通知已读到数据库:', notificationId);
                
                // 发送API请求更新数据库中的isRead属性
                await axios.post('/api/notifications/markAsRead?notiId=' + notificationId);
                
                console.log('通知已读状态同步成功');
            } catch (error) {
                console.error('同步通知已读状态失败:', error);
                // 即使同步失败，前端也保持已读状态，避免用户重复操作
            }
        }
    };

    // 标记所有通知为已读
    const markAllAsRead = async () => {
        notifications.value.forEach(notification => {
            notification.isRead = true;
        });
        updateUnreadCount();
        
        try {
            // 获取用户ID，从sessionStorage中
            const userId = sessionStorage.getItem('userId') || 'default_user';
            console.log('同步标记所有通知已读到数据库', userId);
            
            // 发送API请求更新数据库中所有通知的isRead属性
            await axios.post('/api/notifications/markAllAsRead?userId=' + userId);
            console.log('所有通知已读状态同步成功');
        } catch (error) {
            console.error('同步所有通知已读状态失败:', error);
            // 即使同步失败，前端也保持已读状态，避免用户重复操作
        }
    };

    // 更新未读数量
    const updateUnreadCount = () => {
        unreadCount.value = notifications.value.filter(n => !n.isRead).length;
    };

    // 获取所有未读通知
    const getUnreadNotifications = () => {
        return notifications.value.filter(n => !n.isRead);
    };

    // 根据ID获取单个通知
    const getNotificationById = (notificationId: number) => {
        return notifications.value.find(n => n.id === notificationId);
    };

    // 删除通知
    const deleteNotification = async (notificationId: number) => {
        // 首先从前端数组中移除通知
        const notificationIndex = notifications.value.findIndex(n => n.id === notificationId);
        if (notificationIndex !== -1) {
            notifications.value.splice(notificationIndex, 1);
            updateUnreadCount();
            
            try {
                // 发送API请求到后端删除通知
                await axios.post('/api/notifications/delete?notiId=' + notificationId);
                console.log('通知删除成功同步到后端:', notificationId);
            } catch (error) {
                console.error('同步通知删除到后端失败:', error);
                // 即使同步失败，前端也保持删除状态
            }
        }
    };

    // 从API获取单个通知的详细信息
    const fetchNotificationDetail = async (notificationId: number) => {
        try {
            // 发送请求到后端API获取通知详情
            const response = await axios.get(`/api/notifications/getDetail?notiId=${notificationId}`);
            
            const apiData = response.data;
            
            if (apiData) {
                // 转换数据格式
                const formattedNotification = {
                    id: apiData.notiId,
                    title: apiData.title,
                    message: apiData.content,
                    createdAt: new Date(apiData.notiTime),
                    isRead: apiData.isRead,
                    type: apiData.type.typeName || 'message',
                    status: apiData.status,
                };
                
                return formattedNotification;
            }
        } catch (error) {
            console.error('获取通知详情失败:', error);
            // 返回模拟数据作为备用
            return {
                id: notificationId,
                title: '通知详情',
                message: '无法获取通知详情，请稍后再试。',
                createdAt: new Date(),
                isRead: false,
                type: 'system',
                status: 0,
            };
        }
    };

    // 从API获取通知数据
    const fetchNotificationsFromApi = async () => {
        loading.value = true;
        console.log('开始获取所有通知数据...');
        try {
            // 获取用户ID，从请求头中的token带给后端解析出用户信息，自己拿去用户id
            // 发送请求到后端API获取所有通知数据
            console.log('发送API请求到:', `/api/notifications/getByUid`);

            const response = await axios.get('/api/notifications/getByUid');
            
            console.log('API响应原始数据:', response);
            
            // 转换数据格式，将API返回的字段映射到前端需要的格式
            const apiData = response.data || [];
            console.log('API返回的通知数据:', apiData);
            console.log('通知数据数量:', apiData.length);
            
            if (apiData.length > 0) {
                console.log('开始处理API返回的通知数据...');
                const formattedNotifications = apiData.map((item: any) => {
                    console.log('处理单个通知数据项:', item);
                    return {
                        id: item.notiId,
                        title: item.title,
                        message: item.content,
                        createdAt: new Date(item.notiTime),
                        isRead: item.isRead,
                        type: item.type.typeName || 'message',
                        status: item.status,
                    };
                });
                
                console.log('格式化后的通知数据:', formattedNotifications);
                
                // 按照创建时间倒序排列
                formattedNotifications.sort((a: any, b: any) => 
                    new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
                );
                
                console.log('排序后的通知数据:', formattedNotifications);
                
                // 更新通知列表
                console.log('更新通知列表...');
                setNotifications(formattedNotifications);
                console.log('通知列表更新成功，当前通知数量:', notifications.value.length);
                
                // 无论如何都设置为没有更多数据
                hasMore.value = false;
            } else {
                console.log('API返回空数据，准备添加模拟通知...');
                // 如果API返回空数据，添加一些模拟通知
                addMockNotifications();
                hasMore.value = false;
            }
        } catch (error) {
            console.error('获取通知数据失败:', error);
            // 详细记录错误信息
            if (error.response) {
                console.error('错误响应状态:', error.response.status);
                console.error('错误响应数据:', error.response.data);
            } else if (error.request) {
                console.error('请求已发送但未收到响应:', error.request);
            } else {
                console.error('请求配置错误:', error.message);
            }
            // API调用失败时，添加模拟通知数据
            addMockNotifications();
        } finally {
            loading.value = false;
            console.log('通知数据获取完成，loading状态设为:', loading.value);
        }
    };

    // 添加模拟通知数据
    const addMockNotifications = () => {
        // 只有当通知列表为空时才添加模拟数据
        if (notifications.value.length === 0) {
            const mockNotifications = [
                {
                    id: Date.now() + 1,
                    title: '系统通知',
                    message: '柠檬健康已更新至最新版本，新增健康数据分析功能',
                    createdAt: new Date(Date.now() - 1000 * 60 * 30), // 30分钟前
                    isRead: false,
                    type: 'system'
                },
                {
                    id: Date.now() + 2,
                    title: '健康提醒',
                    message: '您今日的运动量还未达标，建议进行30分钟有氧运动',
                    createdAt: new Date(Date.now() - 1000 * 60 * 60 * 2), // 2小时前
                    isRead: false,
                    type: 'health'
                },
                {
                    id: Date.now() + 3,
                    title: '活动通知',
                    message: '新人专享优惠：首次购买健康产品享受8折优惠',
                    createdAt: new Date(Date.now() - 1000 * 60 * 60 * 24), // 1天前
                    isRead: true,
                    type: 'activity'
                }
            ];
            
            console.log('添加模拟通知数据:', mockNotifications);
            setNotifications(mockNotifications);
            console.log('模拟通知添加完成，当前通知数量:', notifications.value.length);
        } else {
            console.log('通知列表不为空，跳过添加模拟通知');
        }
    };

    // 强制添加测试通知（用于开发测试）
    const forceAddTestNotifications = () => {
        // 生成多个测试通知
        const testNotifications = [];
        const currentTime = Date.now();
        const types = ['system', 'health', 'activity', 'order', 'message'];
        const titles = {
            system: '系统通知',
            health: '健康提醒',
            activity: '活动通知',
            order: '订单通知',
            message: '消息通知'
        };
        const messages = {
            system: ['系统维护通知', '功能更新提醒', '安全提示', '账户信息变更'],
            health: ['运动目标提醒', '健康数据分析', '睡眠质量报告', '饮食建议'],
            activity: ['新活动上线', '限时优惠', '会员专享福利', '节日活动'],
            order: ['订单状态更新', '物流信息通知', '支付成功', '订单已发货'],
            message: ['收到新消息', '评论回复通知', '系统消息', '客服回复']
        };

        // 生成20条测试通知
        for (let i = 0; i < 20; i++) {
            const type = types[Math.floor(Math.random() * types.length)];
            const messageList = messages[type as keyof typeof messages];
            const randomMessage = messageList[Math.floor(Math.random() * messageList.length)];
            
            testNotifications.push({
                id: currentTime + i,
                title: titles[type as keyof typeof titles],
                message: `${randomMessage} - 这是第${i + 1}条测试通知`,
                createdAt: new Date(currentTime - i * 60 * 60 * 1000), // 每条间隔1小时
                isRead: Math.random() > 0.5, // 随机已读/未读状态
                type: type
            });
        }
        
        console.log('添加测试通知数据:', testNotifications);
        setNotifications(testNotifications);
        console.log('测试通知添加完成，当前通知数量:', notifications.value.length);
    };



    return {
        notifications,
        unreadCount,
        hasUnread,
        recentNotifications,
        loading,
        loadingMore,
        hasMore,
        setNotifications,
        addNotification,
        markAsRead,
        markAllAsRead,
        updateUnreadCount,
        getUnreadNotifications,
        getNotificationById,
        fetchNotificationDetail,
        fetchNotificationsFromApi,
        addMockNotifications,
        forceAddTestNotifications,
        deleteNotification
    };
});